// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.adjustment.order.product;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.AdjustmentOrderProduct;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(AdjustmentOrderProduct.class)
@Setter
@Getter
public class AdjustmentOrderProductSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "AdjustmentOrderProduct".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("parentAdjustmentOrder", "ao");
    map.put("prdName", "p");
    map.put("shop", "si");
    map.put("newPrdName", "p2");
    map.put("newShop", "si2");
    map.put("newFnsku", "lf");
    map.put("goodWarehouseBin", "wb");
    map.put("badWarehouseBin", "wb2");
    map.put("newGoodWhb", "wb3");
    map.put("newBadWhb", "wb4");
    map.put("inventoryId", "ipr");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 所属调整单
   */
  private Long parentAdjustmentOrder;

  /**
   * 所属调整单 比较(eq)
   */
  private Long parentAdjustmentOrderEq;
  /**
   * 所属调整单 比较(neq)
   */
  private Long parentAdjustmentOrderNeq;
  /**
   * 所属调整单 比较(gt)
   */
  private Long parentAdjustmentOrderGt;
  /**
   * 所属调整单 比较(gte)
   */
  private Long parentAdjustmentOrderGte;
  /**
   * 所属调整单 比较(lt)
   */
  private Long parentAdjustmentOrderLt;
  /**
   * 所属调整单 比较(lte)
   */
  private Long parentAdjustmentOrderLte;
  /**
   * 所属调整单 比较(contains)
   */
  private Long parentAdjustmentOrderContains;
  /**
   * 所属调整单 比较(notcontains)
   */
  private Long parentAdjustmentOrderNotcontains;
  /**
   * 所属调整单 比较(startswith)
   */
  private Long parentAdjustmentOrderStartswith;
  /**
   * 所属调整单 比较(endswith)
   */
  private Long parentAdjustmentOrderEndswith;
  /**
   * 所属调整单 比较(isnull)
   */
  private Boolean parentAdjustmentOrderIsnull;
  /**
   * 所属调整单 比较(isnotnull)
   */
  private Boolean parentAdjustmentOrderIsnotnull;
  /**
   * 所属调整单的调整单号 比较(eq)
   */
  private String parentAdjustmentOrderOrderSnEq;
  /**
   * 所属调整单的调整单号 比较(neq)
   */
  private String parentAdjustmentOrderOrderSnNeq;
  /**
   * 所属调整单的调整单号 比较(gt)
   */
  private String parentAdjustmentOrderOrderSnGt;
  /**
   * 所属调整单的调整单号 比较(gte)
   */
  private String parentAdjustmentOrderOrderSnGte;
  /**
   * 所属调整单的调整单号 比较(lt)
   */
  private String parentAdjustmentOrderOrderSnLt;
  /**
   * 所属调整单的调整单号 比较(lte)
   */
  private String parentAdjustmentOrderOrderSnLte;
  /**
   * 所属调整单的调整单号 比较(contains)
   */
  private String parentAdjustmentOrderOrderSnContains;
  /**
   * 所属调整单的调整单号 比较(notcontains)
   */
  private String parentAdjustmentOrderOrderSnNotcontains;
  /**
   * 所属调整单的调整单号 比较(startswith)
   */
  private String parentAdjustmentOrderOrderSnStartswith;
  /**
   * 所属调整单的调整单号 比较(endswith)
   */
  private String parentAdjustmentOrderOrderSnEndswith;
  /**
   * 所属调整单的调整单号 比较(isnull)
   */
  private Boolean parentAdjustmentOrderOrderSnIsnull;
  /**
   * 所属调整单的调整单号 比较(isnotnull)
   */
  private Boolean parentAdjustmentOrderOrderSnIsnotnull;

  /**
   * 所属调整单(范围搜索)
   */
  private List<Long> parentAdjustmentOrderInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 是否有 图片
   */
  private Boolean picUrl;

  /**
   * 产品(模糊搜索)
   */
  private String product;

  /**
   * 产品 比较(eq)
   */
  private String productEq;
  /**
   * 产品 比较(neq)
   */
  private String productNeq;
  /**
   * 产品 比较(gt)
   */
  private String productGt;
  /**
   * 产品 比较(gte)
   */
  private String productGte;
  /**
   * 产品 比较(lt)
   */
  private String productLt;
  /**
   * 产品 比较(lte)
   */
  private String productLte;
  /**
   * 产品 比较(contains)
   */
  private String productContains;
  /**
   * 产品 比较(notcontains)
   */
  private String productNotcontains;
  /**
   * 产品 比较(startswith)
   */
  private String productStartswith;
  /**
   * 产品 比较(endswith)
   */
  private String productEndswith;
  /**
   * 产品 比较(isnull)
   */
  private Boolean productIsnull;
  /**
   * 产品 比较(isnotnull)
   */
  private Boolean productIsnotnull;

  /**
   * 产品(精确搜索)
   */
  private List<String> productInList;

  /**
   * 品名
   */
  private Long prdName;

  /**
   * 品名 比较(eq)
   */
  private Long prdNameEq;
  /**
   * 品名 比较(neq)
   */
  private Long prdNameNeq;
  /**
   * 品名 比较(gt)
   */
  private Long prdNameGt;
  /**
   * 品名 比较(gte)
   */
  private Long prdNameGte;
  /**
   * 品名 比较(lt)
   */
  private Long prdNameLt;
  /**
   * 品名 比较(lte)
   */
  private Long prdNameLte;
  /**
   * 品名 比较(contains)
   */
  private Long prdNameContains;
  /**
   * 品名 比较(notcontains)
   */
  private Long prdNameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private Long prdNameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private Long prdNameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean prdNameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean prdNameIsnotnull;
  /**
   * 品名的品名 比较(eq)
   */
  private String prdNameNameEq;
  /**
   * 品名的品名 比较(neq)
   */
  private String prdNameNameNeq;
  /**
   * 品名的品名 比较(gt)
   */
  private String prdNameNameGt;
  /**
   * 品名的品名 比较(gte)
   */
  private String prdNameNameGte;
  /**
   * 品名的品名 比较(lt)
   */
  private String prdNameNameLt;
  /**
   * 品名的品名 比较(lte)
   */
  private String prdNameNameLte;
  /**
   * 品名的品名 比较(contains)
   */
  private String prdNameNameContains;
  /**
   * 品名的品名 比较(notcontains)
   */
  private String prdNameNameNotcontains;
  /**
   * 品名的品名 比较(startswith)
   */
  private String prdNameNameStartswith;
  /**
   * 品名的品名 比较(endswith)
   */
  private String prdNameNameEndswith;
  /**
   * 品名的品名 比较(isnull)
   */
  private Boolean prdNameNameIsnull;
  /**
   * 品名的品名 比较(isnotnull)
   */
  private Boolean prdNameNameIsnotnull;

  /**
   * 品名(范围搜索)
   */
  private List<Long> prdNameInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 产品标签(模糊搜索)
   */
  private String prdLabel;

  /**
   * 产品标签 比较(eq)
   */
  private String prdLabelEq;
  /**
   * 产品标签 比较(neq)
   */
  private String prdLabelNeq;
  /**
   * 产品标签 比较(gt)
   */
  private String prdLabelGt;
  /**
   * 产品标签 比较(gte)
   */
  private String prdLabelGte;
  /**
   * 产品标签 比较(lt)
   */
  private String prdLabelLt;
  /**
   * 产品标签 比较(lte)
   */
  private String prdLabelLte;
  /**
   * 产品标签 比较(contains)
   */
  private String prdLabelContains;
  /**
   * 产品标签 比较(notcontains)
   */
  private String prdLabelNotcontains;
  /**
   * 产品标签 比较(startswith)
   */
  private String prdLabelStartswith;
  /**
   * 产品标签 比较(endswith)
   */
  private String prdLabelEndswith;
  /**
   * 产品标签 比较(isnull)
   */
  private Boolean prdLabelIsnull;
  /**
   * 产品标签 比较(isnotnull)
   */
  private Boolean prdLabelIsnotnull;

  /**
   * 产品标签(精确搜索)
   */
  private List<String> prdLabelInList;

  /**
   * 店铺
   */
  private Long shop;

  /**
   * 店铺 比较(eq)
   */
  private Long shopEq;
  /**
   * 店铺 比较(neq)
   */
  private Long shopNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long shopGt;
  /**
   * 店铺 比较(gte)
   */
  private Long shopGte;
  /**
   * 店铺 比较(lt)
   */
  private Long shopLt;
  /**
   * 店铺 比较(lte)
   */
  private Long shopLte;
  /**
   * 店铺 比较(contains)
   */
  private Long shopContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long shopNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long shopStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long shopEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean shopIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean shopIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String shopShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String shopShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String shopShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String shopShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String shopShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String shopShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String shopShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String shopShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String shopShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String shopShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean shopShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean shopShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> shopInList;

  /**
   * FNSKU
   */
  private Long fnsku;

  /**
   * FNSKU 比较(eq)
   */
  private Long fnskuEq;
  /**
   * FNSKU 比较(neq)
   */
  private Long fnskuNeq;
  /**
   * FNSKU 比较(gt)
   */
  private Long fnskuGt;
  /**
   * FNSKU 比较(gte)
   */
  private Long fnskuGte;
  /**
   * FNSKU 比较(lt)
   */
  private Long fnskuLt;
  /**
   * FNSKU 比较(lte)
   */
  private Long fnskuLte;
  /**
   * FNSKU 比较(contains)
   */
  private Long fnskuContains;
  /**
   * FNSKU 比较(notcontains)
   */
  private Long fnskuNotcontains;
  /**
   * FNSKU 比较(startswith)
   */
  private Long fnskuStartswith;
  /**
   * FNSKU 比较(endswith)
   */
  private Long fnskuEndswith;
  /**
   * FNSKU 比较(isnull)
   */
  private Boolean fnskuIsnull;
  /**
   * FNSKU 比较(isnotnull)
   */
  private Boolean fnskuIsnotnull;
  /**
   * FNSKU的FNSKU 比较(eq)
   */
  private String fnskuFnskuEq;
  /**
   * FNSKU的FNSKU 比较(neq)
   */
  private String fnskuFnskuNeq;
  /**
   * FNSKU的FNSKU 比较(gt)
   */
  private String fnskuFnskuGt;
  /**
   * FNSKU的FNSKU 比较(gte)
   */
  private String fnskuFnskuGte;
  /**
   * FNSKU的FNSKU 比较(lt)
   */
  private String fnskuFnskuLt;
  /**
   * FNSKU的FNSKU 比较(lte)
   */
  private String fnskuFnskuLte;
  /**
   * FNSKU的FNSKU 比较(contains)
   */
  private String fnskuFnskuContains;
  /**
   * FNSKU的FNSKU 比较(notcontains)
   */
  private String fnskuFnskuNotcontains;
  /**
   * FNSKU的FNSKU 比较(startswith)
   */
  private String fnskuFnskuStartswith;
  /**
   * FNSKU的FNSKU 比较(endswith)
   */
  private String fnskuFnskuEndswith;
  /**
   * FNSKU的FNSKU 比较(isnull)
   */
  private Boolean fnskuFnskuIsnull;
  /**
   * FNSKU的FNSKU 比较(isnotnull)
   */
  private Boolean fnskuFnskuIsnotnull;

  /**
   * FNSKU(范围搜索)
   */
  private List<Long> fnskuInList;

  /**
   * 新品名
   */
  private Long newPrdName;

  /**
   * 新品名 比较(eq)
   */
  private Long newPrdNameEq;
  /**
   * 新品名 比较(neq)
   */
  private Long newPrdNameNeq;
  /**
   * 新品名 比较(gt)
   */
  private Long newPrdNameGt;
  /**
   * 新品名 比较(gte)
   */
  private Long newPrdNameGte;
  /**
   * 新品名 比较(lt)
   */
  private Long newPrdNameLt;
  /**
   * 新品名 比较(lte)
   */
  private Long newPrdNameLte;
  /**
   * 新品名 比较(contains)
   */
  private Long newPrdNameContains;
  /**
   * 新品名 比较(notcontains)
   */
  private Long newPrdNameNotcontains;
  /**
   * 新品名 比较(startswith)
   */
  private Long newPrdNameStartswith;
  /**
   * 新品名 比较(endswith)
   */
  private Long newPrdNameEndswith;
  /**
   * 新品名 比较(isnull)
   */
  private Boolean newPrdNameIsnull;
  /**
   * 新品名 比较(isnotnull)
   */
  private Boolean newPrdNameIsnotnull;
  /**
   * 新品名的品名 比较(eq)
   */
  private String newPrdNameNameEq;
  /**
   * 新品名的品名 比较(neq)
   */
  private String newPrdNameNameNeq;
  /**
   * 新品名的品名 比较(gt)
   */
  private String newPrdNameNameGt;
  /**
   * 新品名的品名 比较(gte)
   */
  private String newPrdNameNameGte;
  /**
   * 新品名的品名 比较(lt)
   */
  private String newPrdNameNameLt;
  /**
   * 新品名的品名 比较(lte)
   */
  private String newPrdNameNameLte;
  /**
   * 新品名的品名 比较(contains)
   */
  private String newPrdNameNameContains;
  /**
   * 新品名的品名 比较(notcontains)
   */
  private String newPrdNameNameNotcontains;
  /**
   * 新品名的品名 比较(startswith)
   */
  private String newPrdNameNameStartswith;
  /**
   * 新品名的品名 比较(endswith)
   */
  private String newPrdNameNameEndswith;
  /**
   * 新品名的品名 比较(isnull)
   */
  private Boolean newPrdNameNameIsnull;
  /**
   * 新品名的品名 比较(isnotnull)
   */
  private Boolean newPrdNameNameIsnotnull;

  /**
   * 新品名(范围搜索)
   */
  private List<Long> newPrdNameInList;

  /**
   * 新SKU(模糊搜索)
   */
  private String newSku;

  /**
   * 新SKU 比较(eq)
   */
  private String newSkuEq;
  /**
   * 新SKU 比较(neq)
   */
  private String newSkuNeq;
  /**
   * 新SKU 比较(gt)
   */
  private String newSkuGt;
  /**
   * 新SKU 比较(gte)
   */
  private String newSkuGte;
  /**
   * 新SKU 比较(lt)
   */
  private String newSkuLt;
  /**
   * 新SKU 比较(lte)
   */
  private String newSkuLte;
  /**
   * 新SKU 比较(contains)
   */
  private String newSkuContains;
  /**
   * 新SKU 比较(notcontains)
   */
  private String newSkuNotcontains;
  /**
   * 新SKU 比较(startswith)
   */
  private String newSkuStartswith;
  /**
   * 新SKU 比较(endswith)
   */
  private String newSkuEndswith;
  /**
   * 新SKU 比较(isnull)
   */
  private Boolean newSkuIsnull;
  /**
   * 新SKU 比较(isnotnull)
   */
  private Boolean newSkuIsnotnull;

  /**
   * 新SKU(精确搜索)
   */
  private List<String> newSkuInList;

  /**
   * 新店铺
   */
  private Long newShop;

  /**
   * 新店铺 比较(eq)
   */
  private Long newShopEq;
  /**
   * 新店铺 比较(neq)
   */
  private Long newShopNeq;
  /**
   * 新店铺 比较(gt)
   */
  private Long newShopGt;
  /**
   * 新店铺 比较(gte)
   */
  private Long newShopGte;
  /**
   * 新店铺 比较(lt)
   */
  private Long newShopLt;
  /**
   * 新店铺 比较(lte)
   */
  private Long newShopLte;
  /**
   * 新店铺 比较(contains)
   */
  private Long newShopContains;
  /**
   * 新店铺 比较(notcontains)
   */
  private Long newShopNotcontains;
  /**
   * 新店铺 比较(startswith)
   */
  private Long newShopStartswith;
  /**
   * 新店铺 比较(endswith)
   */
  private Long newShopEndswith;
  /**
   * 新店铺 比较(isnull)
   */
  private Boolean newShopIsnull;
  /**
   * 新店铺 比较(isnotnull)
   */
  private Boolean newShopIsnotnull;
  /**
   * 新店铺的名称 比较(eq)
   */
  private String newShopShopNameEq;
  /**
   * 新店铺的名称 比较(neq)
   */
  private String newShopShopNameNeq;
  /**
   * 新店铺的名称 比较(gt)
   */
  private String newShopShopNameGt;
  /**
   * 新店铺的名称 比较(gte)
   */
  private String newShopShopNameGte;
  /**
   * 新店铺的名称 比较(lt)
   */
  private String newShopShopNameLt;
  /**
   * 新店铺的名称 比较(lte)
   */
  private String newShopShopNameLte;
  /**
   * 新店铺的名称 比较(contains)
   */
  private String newShopShopNameContains;
  /**
   * 新店铺的名称 比较(notcontains)
   */
  private String newShopShopNameNotcontains;
  /**
   * 新店铺的名称 比较(startswith)
   */
  private String newShopShopNameStartswith;
  /**
   * 新店铺的名称 比较(endswith)
   */
  private String newShopShopNameEndswith;
  /**
   * 新店铺的名称 比较(isnull)
   */
  private Boolean newShopShopNameIsnull;
  /**
   * 新店铺的名称 比较(isnotnull)
   */
  private Boolean newShopShopNameIsnotnull;

  /**
   * 新店铺(范围搜索)
   */
  private List<Long> newShopInList;

  /**
   * 新FNSKU
   */
  private Long newFnsku;

  /**
   * 新FNSKU 比较(eq)
   */
  private Long newFnskuEq;
  /**
   * 新FNSKU 比较(neq)
   */
  private Long newFnskuNeq;
  /**
   * 新FNSKU 比较(gt)
   */
  private Long newFnskuGt;
  /**
   * 新FNSKU 比较(gte)
   */
  private Long newFnskuGte;
  /**
   * 新FNSKU 比较(lt)
   */
  private Long newFnskuLt;
  /**
   * 新FNSKU 比较(lte)
   */
  private Long newFnskuLte;
  /**
   * 新FNSKU 比较(contains)
   */
  private Long newFnskuContains;
  /**
   * 新FNSKU 比较(notcontains)
   */
  private Long newFnskuNotcontains;
  /**
   * 新FNSKU 比较(startswith)
   */
  private Long newFnskuStartswith;
  /**
   * 新FNSKU 比较(endswith)
   */
  private Long newFnskuEndswith;
  /**
   * 新FNSKU 比较(isnull)
   */
  private Boolean newFnskuIsnull;
  /**
   * 新FNSKU 比较(isnotnull)
   */
  private Boolean newFnskuIsnotnull;
  /**
   * 新FNSKU的FNSKU 比较(eq)
   */
  private String newFnskuFnskuEq;
  /**
   * 新FNSKU的FNSKU 比较(neq)
   */
  private String newFnskuFnskuNeq;
  /**
   * 新FNSKU的FNSKU 比较(gt)
   */
  private String newFnskuFnskuGt;
  /**
   * 新FNSKU的FNSKU 比较(gte)
   */
  private String newFnskuFnskuGte;
  /**
   * 新FNSKU的FNSKU 比较(lt)
   */
  private String newFnskuFnskuLt;
  /**
   * 新FNSKU的FNSKU 比较(lte)
   */
  private String newFnskuFnskuLte;
  /**
   * 新FNSKU的FNSKU 比较(contains)
   */
  private String newFnskuFnskuContains;
  /**
   * 新FNSKU的FNSKU 比较(notcontains)
   */
  private String newFnskuFnskuNotcontains;
  /**
   * 新FNSKU的FNSKU 比较(startswith)
   */
  private String newFnskuFnskuStartswith;
  /**
   * 新FNSKU的FNSKU 比较(endswith)
   */
  private String newFnskuFnskuEndswith;
  /**
   * 新FNSKU的FNSKU 比较(isnull)
   */
  private Boolean newFnskuFnskuIsnull;
  /**
   * 新FNSKU的FNSKU 比较(isnotnull)
   */
  private Boolean newFnskuFnskuIsnotnull;

  /**
   * 新FNSKU(范围搜索)
   */
  private List<Long> newFnskuInList;

  /**
   * 可用量
   */
  private Long availbleNum;

  /**
   * 最小可用量
   */
  private Long availbleNumMin;

  /**
   * 最大可用量
   */
  private Long availbleNumMax;

  /**
   * 可用量 比较(eq)
   */
  private Long availbleNumEq;
  /**
   * 可用量 比较(neq)
   */
  private Long availbleNumNeq;
  /**
   * 可用量 比较(gt)
   */
  private Long availbleNumGt;
  /**
   * 可用量 比较(gte)
   */
  private Long availbleNumGte;
  /**
   * 可用量 比较(lt)
   */
  private Long availbleNumLt;
  /**
   * 可用量 比较(lte)
   */
  private Long availbleNumLte;
  /**
   * 可用量 比较(contains)
   */
  private Long availbleNumContains;
  /**
   * 可用量 比较(notcontains)
   */
  private Long availbleNumNotcontains;
  /**
   * 可用量 比较(startswith)
   */
  private Long availbleNumStartswith;
  /**
   * 可用量 比较(endswith)
   */
  private Long availbleNumEndswith;
  /**
   * 可用量 比较(isnull)
   */
  private Boolean availbleNumIsnull;
  /**
   * 可用量 比较(isnotnull)
   */
  private Boolean availbleNumIsnotnull;

  /**
   * 新可用量
   */
  private Long newAvailbleNum;

  /**
   * 最小新可用量
   */
  private Long newAvailbleNumMin;

  /**
   * 最大新可用量
   */
  private Long newAvailbleNumMax;

  /**
   * 新可用量 比较(eq)
   */
  private Long newAvailbleNumEq;
  /**
   * 新可用量 比较(neq)
   */
  private Long newAvailbleNumNeq;
  /**
   * 新可用量 比较(gt)
   */
  private Long newAvailbleNumGt;
  /**
   * 新可用量 比较(gte)
   */
  private Long newAvailbleNumGte;
  /**
   * 新可用量 比较(lt)
   */
  private Long newAvailbleNumLt;
  /**
   * 新可用量 比较(lte)
   */
  private Long newAvailbleNumLte;
  /**
   * 新可用量 比较(contains)
   */
  private Long newAvailbleNumContains;
  /**
   * 新可用量 比较(notcontains)
   */
  private Long newAvailbleNumNotcontains;
  /**
   * 新可用量 比较(startswith)
   */
  private Long newAvailbleNumStartswith;
  /**
   * 新可用量 比较(endswith)
   */
  private Long newAvailbleNumEndswith;
  /**
   * 新可用量 比较(isnull)
   */
  private Boolean newAvailbleNumIsnull;
  /**
   * 新可用量 比较(isnotnull)
   */
  private Boolean newAvailbleNumIsnotnull;

  /**
   * 可用调整量
   */
  private Long goodAdjustNum;

  /**
   * 最小可用调整量
   */
  private Long goodAdjustNumMin;

  /**
   * 最大可用调整量
   */
  private Long goodAdjustNumMax;

  /**
   * 可用调整量 比较(eq)
   */
  private Long goodAdjustNumEq;
  /**
   * 可用调整量 比较(neq)
   */
  private Long goodAdjustNumNeq;
  /**
   * 可用调整量 比较(gt)
   */
  private Long goodAdjustNumGt;
  /**
   * 可用调整量 比较(gte)
   */
  private Long goodAdjustNumGte;
  /**
   * 可用调整量 比较(lt)
   */
  private Long goodAdjustNumLt;
  /**
   * 可用调整量 比较(lte)
   */
  private Long goodAdjustNumLte;
  /**
   * 可用调整量 比较(contains)
   */
  private Long goodAdjustNumContains;
  /**
   * 可用调整量 比较(notcontains)
   */
  private Long goodAdjustNumNotcontains;
  /**
   * 可用调整量 比较(startswith)
   */
  private Long goodAdjustNumStartswith;
  /**
   * 可用调整量 比较(endswith)
   */
  private Long goodAdjustNumEndswith;
  /**
   * 可用调整量 比较(isnull)
   */
  private Boolean goodAdjustNumIsnull;
  /**
   * 可用调整量 比较(isnotnull)
   */
  private Boolean goodAdjustNumIsnotnull;

  /**
   * 次品量
   */
  private Long defectiveQuantity;

  /**
   * 最小次品量
   */
  private Long defectiveQuantityMin;

  /**
   * 最大次品量
   */
  private Long defectiveQuantityMax;

  /**
   * 次品量 比较(eq)
   */
  private Long defectiveQuantityEq;
  /**
   * 次品量 比较(neq)
   */
  private Long defectiveQuantityNeq;
  /**
   * 次品量 比较(gt)
   */
  private Long defectiveQuantityGt;
  /**
   * 次品量 比较(gte)
   */
  private Long defectiveQuantityGte;
  /**
   * 次品量 比较(lt)
   */
  private Long defectiveQuantityLt;
  /**
   * 次品量 比较(lte)
   */
  private Long defectiveQuantityLte;
  /**
   * 次品量 比较(contains)
   */
  private Long defectiveQuantityContains;
  /**
   * 次品量 比较(notcontains)
   */
  private Long defectiveQuantityNotcontains;
  /**
   * 次品量 比较(startswith)
   */
  private Long defectiveQuantityStartswith;
  /**
   * 次品量 比较(endswith)
   */
  private Long defectiveQuantityEndswith;
  /**
   * 次品量 比较(isnull)
   */
  private Boolean defectiveQuantityIsnull;
  /**
   * 次品量 比较(isnotnull)
   */
  private Boolean defectiveQuantityIsnotnull;

  /**
   * 次品调整量
   */
  private Long badAdjustNum;

  /**
   * 最小次品调整量
   */
  private Long badAdjustNumMin;

  /**
   * 最大次品调整量
   */
  private Long badAdjustNumMax;

  /**
   * 次品调整量 比较(eq)
   */
  private Long badAdjustNumEq;
  /**
   * 次品调整量 比较(neq)
   */
  private Long badAdjustNumNeq;
  /**
   * 次品调整量 比较(gt)
   */
  private Long badAdjustNumGt;
  /**
   * 次品调整量 比较(gte)
   */
  private Long badAdjustNumGte;
  /**
   * 次品调整量 比较(lt)
   */
  private Long badAdjustNumLt;
  /**
   * 次品调整量 比较(lte)
   */
  private Long badAdjustNumLte;
  /**
   * 次品调整量 比较(contains)
   */
  private Long badAdjustNumContains;
  /**
   * 次品调整量 比较(notcontains)
   */
  private Long badAdjustNumNotcontains;
  /**
   * 次品调整量 比较(startswith)
   */
  private Long badAdjustNumStartswith;
  /**
   * 次品调整量 比较(endswith)
   */
  private Long badAdjustNumEndswith;
  /**
   * 次品调整量 比较(isnull)
   */
  private Boolean badAdjustNumIsnull;
  /**
   * 次品调整量 比较(isnotnull)
   */
  private Boolean badAdjustNumIsnotnull;

  /**
   * 调整量
   */
  private Long adjustmentAmount;

  /**
   * 最小调整量
   */
  private Long adjustmentAmountMin;

  /**
   * 最大调整量
   */
  private Long adjustmentAmountMax;

  /**
   * 调整量 比较(eq)
   */
  private Long adjustmentAmountEq;
  /**
   * 调整量 比较(neq)
   */
  private Long adjustmentAmountNeq;
  /**
   * 调整量 比较(gt)
   */
  private Long adjustmentAmountGt;
  /**
   * 调整量 比较(gte)
   */
  private Long adjustmentAmountGte;
  /**
   * 调整量 比较(lt)
   */
  private Long adjustmentAmountLt;
  /**
   * 调整量 比较(lte)
   */
  private Long adjustmentAmountLte;
  /**
   * 调整量 比较(contains)
   */
  private Long adjustmentAmountContains;
  /**
   * 调整量 比较(notcontains)
   */
  private Long adjustmentAmountNotcontains;
  /**
   * 调整量 比较(startswith)
   */
  private Long adjustmentAmountStartswith;
  /**
   * 调整量 比较(endswith)
   */
  private Long adjustmentAmountEndswith;
  /**
   * 调整量 比较(isnull)
   */
  private Boolean adjustmentAmountIsnull;
  /**
   * 调整量 比较(isnotnull)
   */
  private Boolean adjustmentAmountIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 出库仓位
   */
  private Long goodWarehouseBin;

  /**
   * 出库仓位 比较(eq)
   */
  private Long goodWarehouseBinEq;
  /**
   * 出库仓位 比较(neq)
   */
  private Long goodWarehouseBinNeq;
  /**
   * 出库仓位 比较(gt)
   */
  private Long goodWarehouseBinGt;
  /**
   * 出库仓位 比较(gte)
   */
  private Long goodWarehouseBinGte;
  /**
   * 出库仓位 比较(lt)
   */
  private Long goodWarehouseBinLt;
  /**
   * 出库仓位 比较(lte)
   */
  private Long goodWarehouseBinLte;
  /**
   * 出库仓位 比较(contains)
   */
  private Long goodWarehouseBinContains;
  /**
   * 出库仓位 比较(notcontains)
   */
  private Long goodWarehouseBinNotcontains;
  /**
   * 出库仓位 比较(startswith)
   */
  private Long goodWarehouseBinStartswith;
  /**
   * 出库仓位 比较(endswith)
   */
  private Long goodWarehouseBinEndswith;
  /**
   * 出库仓位 比较(isnull)
   */
  private Boolean goodWarehouseBinIsnull;
  /**
   * 出库仓位 比较(isnotnull)
   */
  private Boolean goodWarehouseBinIsnotnull;
  /**
   * 出库仓位的仓位 比较(eq)
   */
  private String goodWarehouseBinStorageBinEq;
  /**
   * 出库仓位的仓位 比较(neq)
   */
  private String goodWarehouseBinStorageBinNeq;
  /**
   * 出库仓位的仓位 比较(gt)
   */
  private String goodWarehouseBinStorageBinGt;
  /**
   * 出库仓位的仓位 比较(gte)
   */
  private String goodWarehouseBinStorageBinGte;
  /**
   * 出库仓位的仓位 比较(lt)
   */
  private String goodWarehouseBinStorageBinLt;
  /**
   * 出库仓位的仓位 比较(lte)
   */
  private String goodWarehouseBinStorageBinLte;
  /**
   * 出库仓位的仓位 比较(contains)
   */
  private String goodWarehouseBinStorageBinContains;
  /**
   * 出库仓位的仓位 比较(notcontains)
   */
  private String goodWarehouseBinStorageBinNotcontains;
  /**
   * 出库仓位的仓位 比较(startswith)
   */
  private String goodWarehouseBinStorageBinStartswith;
  /**
   * 出库仓位的仓位 比较(endswith)
   */
  private String goodWarehouseBinStorageBinEndswith;
  /**
   * 出库仓位的仓位 比较(isnull)
   */
  private Boolean goodWarehouseBinStorageBinIsnull;
  /**
   * 出库仓位的仓位 比较(isnotnull)
   */
  private Boolean goodWarehouseBinStorageBinIsnotnull;

  /**
   * 出库仓位(范围搜索)
   */
  private List<Long> goodWarehouseBinInList;

  /**
   * 次品仓位
   */
  private Long badWarehouseBin;

  /**
   * 次品仓位 比较(eq)
   */
  private Long badWarehouseBinEq;
  /**
   * 次品仓位 比较(neq)
   */
  private Long badWarehouseBinNeq;
  /**
   * 次品仓位 比较(gt)
   */
  private Long badWarehouseBinGt;
  /**
   * 次品仓位 比较(gte)
   */
  private Long badWarehouseBinGte;
  /**
   * 次品仓位 比较(lt)
   */
  private Long badWarehouseBinLt;
  /**
   * 次品仓位 比较(lte)
   */
  private Long badWarehouseBinLte;
  /**
   * 次品仓位 比较(contains)
   */
  private Long badWarehouseBinContains;
  /**
   * 次品仓位 比较(notcontains)
   */
  private Long badWarehouseBinNotcontains;
  /**
   * 次品仓位 比较(startswith)
   */
  private Long badWarehouseBinStartswith;
  /**
   * 次品仓位 比较(endswith)
   */
  private Long badWarehouseBinEndswith;
  /**
   * 次品仓位 比较(isnull)
   */
  private Boolean badWarehouseBinIsnull;
  /**
   * 次品仓位 比较(isnotnull)
   */
  private Boolean badWarehouseBinIsnotnull;
  /**
   * 次品仓位的仓位 比较(eq)
   */
  private String badWarehouseBinStorageBinEq;
  /**
   * 次品仓位的仓位 比较(neq)
   */
  private String badWarehouseBinStorageBinNeq;
  /**
   * 次品仓位的仓位 比较(gt)
   */
  private String badWarehouseBinStorageBinGt;
  /**
   * 次品仓位的仓位 比较(gte)
   */
  private String badWarehouseBinStorageBinGte;
  /**
   * 次品仓位的仓位 比较(lt)
   */
  private String badWarehouseBinStorageBinLt;
  /**
   * 次品仓位的仓位 比较(lte)
   */
  private String badWarehouseBinStorageBinLte;
  /**
   * 次品仓位的仓位 比较(contains)
   */
  private String badWarehouseBinStorageBinContains;
  /**
   * 次品仓位的仓位 比较(notcontains)
   */
  private String badWarehouseBinStorageBinNotcontains;
  /**
   * 次品仓位的仓位 比较(startswith)
   */
  private String badWarehouseBinStorageBinStartswith;
  /**
   * 次品仓位的仓位 比较(endswith)
   */
  private String badWarehouseBinStorageBinEndswith;
  /**
   * 次品仓位的仓位 比较(isnull)
   */
  private Boolean badWarehouseBinStorageBinIsnull;
  /**
   * 次品仓位的仓位 比较(isnotnull)
   */
  private Boolean badWarehouseBinStorageBinIsnotnull;

  /**
   * 次品仓位(范围搜索)
   */
  private List<Long> badWarehouseBinInList;

  /**
   * 入库仓位
   */
  private Long newGoodWhb;

  /**
   * 入库仓位 比较(eq)
   */
  private Long newGoodWhbEq;
  /**
   * 入库仓位 比较(neq)
   */
  private Long newGoodWhbNeq;
  /**
   * 入库仓位 比较(gt)
   */
  private Long newGoodWhbGt;
  /**
   * 入库仓位 比较(gte)
   */
  private Long newGoodWhbGte;
  /**
   * 入库仓位 比较(lt)
   */
  private Long newGoodWhbLt;
  /**
   * 入库仓位 比较(lte)
   */
  private Long newGoodWhbLte;
  /**
   * 入库仓位 比较(contains)
   */
  private Long newGoodWhbContains;
  /**
   * 入库仓位 比较(notcontains)
   */
  private Long newGoodWhbNotcontains;
  /**
   * 入库仓位 比较(startswith)
   */
  private Long newGoodWhbStartswith;
  /**
   * 入库仓位 比较(endswith)
   */
  private Long newGoodWhbEndswith;
  /**
   * 入库仓位 比较(isnull)
   */
  private Boolean newGoodWhbIsnull;
  /**
   * 入库仓位 比较(isnotnull)
   */
  private Boolean newGoodWhbIsnotnull;
  /**
   * 入库仓位的仓位 比较(eq)
   */
  private String newGoodWhbStorageBinEq;
  /**
   * 入库仓位的仓位 比较(neq)
   */
  private String newGoodWhbStorageBinNeq;
  /**
   * 入库仓位的仓位 比较(gt)
   */
  private String newGoodWhbStorageBinGt;
  /**
   * 入库仓位的仓位 比较(gte)
   */
  private String newGoodWhbStorageBinGte;
  /**
   * 入库仓位的仓位 比较(lt)
   */
  private String newGoodWhbStorageBinLt;
  /**
   * 入库仓位的仓位 比较(lte)
   */
  private String newGoodWhbStorageBinLte;
  /**
   * 入库仓位的仓位 比较(contains)
   */
  private String newGoodWhbStorageBinContains;
  /**
   * 入库仓位的仓位 比较(notcontains)
   */
  private String newGoodWhbStorageBinNotcontains;
  /**
   * 入库仓位的仓位 比较(startswith)
   */
  private String newGoodWhbStorageBinStartswith;
  /**
   * 入库仓位的仓位 比较(endswith)
   */
  private String newGoodWhbStorageBinEndswith;
  /**
   * 入库仓位的仓位 比较(isnull)
   */
  private Boolean newGoodWhbStorageBinIsnull;
  /**
   * 入库仓位的仓位 比较(isnotnull)
   */
  private Boolean newGoodWhbStorageBinIsnotnull;

  /**
   * 入库仓位(范围搜索)
   */
  private List<Long> newGoodWhbInList;

  /**
   * 新次品仓位
   */
  private Long newBadWhb;

  /**
   * 新次品仓位 比较(eq)
   */
  private Long newBadWhbEq;
  /**
   * 新次品仓位 比较(neq)
   */
  private Long newBadWhbNeq;
  /**
   * 新次品仓位 比较(gt)
   */
  private Long newBadWhbGt;
  /**
   * 新次品仓位 比较(gte)
   */
  private Long newBadWhbGte;
  /**
   * 新次品仓位 比较(lt)
   */
  private Long newBadWhbLt;
  /**
   * 新次品仓位 比较(lte)
   */
  private Long newBadWhbLte;
  /**
   * 新次品仓位 比较(contains)
   */
  private Long newBadWhbContains;
  /**
   * 新次品仓位 比较(notcontains)
   */
  private Long newBadWhbNotcontains;
  /**
   * 新次品仓位 比较(startswith)
   */
  private Long newBadWhbStartswith;
  /**
   * 新次品仓位 比较(endswith)
   */
  private Long newBadWhbEndswith;
  /**
   * 新次品仓位 比较(isnull)
   */
  private Boolean newBadWhbIsnull;
  /**
   * 新次品仓位 比较(isnotnull)
   */
  private Boolean newBadWhbIsnotnull;
  /**
   * 新次品仓位的仓位 比较(eq)
   */
  private String newBadWhbStorageBinEq;
  /**
   * 新次品仓位的仓位 比较(neq)
   */
  private String newBadWhbStorageBinNeq;
  /**
   * 新次品仓位的仓位 比较(gt)
   */
  private String newBadWhbStorageBinGt;
  /**
   * 新次品仓位的仓位 比较(gte)
   */
  private String newBadWhbStorageBinGte;
  /**
   * 新次品仓位的仓位 比较(lt)
   */
  private String newBadWhbStorageBinLt;
  /**
   * 新次品仓位的仓位 比较(lte)
   */
  private String newBadWhbStorageBinLte;
  /**
   * 新次品仓位的仓位 比较(contains)
   */
  private String newBadWhbStorageBinContains;
  /**
   * 新次品仓位的仓位 比较(notcontains)
   */
  private String newBadWhbStorageBinNotcontains;
  /**
   * 新次品仓位的仓位 比较(startswith)
   */
  private String newBadWhbStorageBinStartswith;
  /**
   * 新次品仓位的仓位 比较(endswith)
   */
  private String newBadWhbStorageBinEndswith;
  /**
   * 新次品仓位的仓位 比较(isnull)
   */
  private Boolean newBadWhbStorageBinIsnull;
  /**
   * 新次品仓位的仓位 比较(isnotnull)
   */
  private Boolean newBadWhbStorageBinIsnotnull;

  /**
   * 新次品仓位(范围搜索)
   */
  private List<Long> newBadWhbInList;

  /**
   * 备注(模糊搜索)
   */
  private String remark;

  /**
   * 备注 比较(eq)
   */
  private String remarkEq;
  /**
   * 备注 比较(neq)
   */
  private String remarkNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarkGt;
  /**
   * 备注 比较(gte)
   */
  private String remarkGte;
  /**
   * 备注 比较(lt)
   */
  private String remarkLt;
  /**
   * 备注 比较(lte)
   */
  private String remarkLte;
  /**
   * 备注 比较(contains)
   */
  private String remarkContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarkNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarkStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarkEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarkIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarkIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarkInList;

  /**
   * 库存
   */
  private Long inventoryId;

  /**
   * 库存 比较(eq)
   */
  private Long inventoryIdEq;
  /**
   * 库存 比较(neq)
   */
  private Long inventoryIdNeq;
  /**
   * 库存 比较(gt)
   */
  private Long inventoryIdGt;
  /**
   * 库存 比较(gte)
   */
  private Long inventoryIdGte;
  /**
   * 库存 比较(lt)
   */
  private Long inventoryIdLt;
  /**
   * 库存 比较(lte)
   */
  private Long inventoryIdLte;
  /**
   * 库存 比较(contains)
   */
  private Long inventoryIdContains;
  /**
   * 库存 比较(notcontains)
   */
  private Long inventoryIdNotcontains;
  /**
   * 库存 比较(startswith)
   */
  private Long inventoryIdStartswith;
  /**
   * 库存 比较(endswith)
   */
  private Long inventoryIdEndswith;
  /**
   * 库存 比较(isnull)
   */
  private Boolean inventoryIdIsnull;
  /**
   * 库存 比较(isnotnull)
   */
  private Boolean inventoryIdIsnotnull;
  /**
   * 库存的编号 比较(eq)
   */
  private Long inventoryIdIdEq;
  /**
   * 库存的编号 比较(neq)
   */
  private Long inventoryIdIdNeq;
  /**
   * 库存的编号 比较(gt)
   */
  private Long inventoryIdIdGt;
  /**
   * 库存的编号 比较(gte)
   */
  private Long inventoryIdIdGte;
  /**
   * 库存的编号 比较(lt)
   */
  private Long inventoryIdIdLt;
  /**
   * 库存的编号 比较(lte)
   */
  private Long inventoryIdIdLte;
  /**
   * 库存的编号 比较(contains)
   */
  private Long inventoryIdIdContains;
  /**
   * 库存的编号 比较(notcontains)
   */
  private Long inventoryIdIdNotcontains;
  /**
   * 库存的编号 比较(startswith)
   */
  private Long inventoryIdIdStartswith;
  /**
   * 库存的编号 比较(endswith)
   */
  private Long inventoryIdIdEndswith;
  /**
   * 库存的编号 比较(isnull)
   */
  private Boolean inventoryIdIdIsnull;
  /**
   * 库存的编号 比较(isnotnull)
   */
  private Boolean inventoryIdIdIsnotnull;

  /**
   * 库存(范围搜索)
   */
  private List<Long> inventoryIdInList;

  /**
   * fnsku名称(模糊搜索)
   */
  private String fnskuName;

  /**
   * fnsku名称 比较(eq)
   */
  private String fnskuNameEq;
  /**
   * fnsku名称 比较(neq)
   */
  private String fnskuNameNeq;
  /**
   * fnsku名称 比较(gt)
   */
  private String fnskuNameGt;
  /**
   * fnsku名称 比较(gte)
   */
  private String fnskuNameGte;
  /**
   * fnsku名称 比较(lt)
   */
  private String fnskuNameLt;
  /**
   * fnsku名称 比较(lte)
   */
  private String fnskuNameLte;
  /**
   * fnsku名称 比较(contains)
   */
  private String fnskuNameContains;
  /**
   * fnsku名称 比较(notcontains)
   */
  private String fnskuNameNotcontains;
  /**
   * fnsku名称 比较(startswith)
   */
  private String fnskuNameStartswith;
  /**
   * fnsku名称 比较(endswith)
   */
  private String fnskuNameEndswith;
  /**
   * fnsku名称 比较(isnull)
   */
  private Boolean fnskuNameIsnull;
  /**
   * fnsku名称 比较(isnotnull)
   */
  private Boolean fnskuNameIsnotnull;

  /**
   * fnsku名称(精确搜索)
   */
  private List<String> fnskuNameInList;

  /**
   * 新Fnsku名称(模糊搜索)
   */
  private String newFnskuName;

  /**
   * 新Fnsku名称 比较(eq)
   */
  private String newFnskuNameEq;
  /**
   * 新Fnsku名称 比较(neq)
   */
  private String newFnskuNameNeq;
  /**
   * 新Fnsku名称 比较(gt)
   */
  private String newFnskuNameGt;
  /**
   * 新Fnsku名称 比较(gte)
   */
  private String newFnskuNameGte;
  /**
   * 新Fnsku名称 比较(lt)
   */
  private String newFnskuNameLt;
  /**
   * 新Fnsku名称 比较(lte)
   */
  private String newFnskuNameLte;
  /**
   * 新Fnsku名称 比较(contains)
   */
  private String newFnskuNameContains;
  /**
   * 新Fnsku名称 比较(notcontains)
   */
  private String newFnskuNameNotcontains;
  /**
   * 新Fnsku名称 比较(startswith)
   */
  private String newFnskuNameStartswith;
  /**
   * 新Fnsku名称 比较(endswith)
   */
  private String newFnskuNameEndswith;
  /**
   * 新Fnsku名称 比较(isnull)
   */
  private Boolean newFnskuNameIsnull;
  /**
   * 新Fnsku名称 比较(isnotnull)
   */
  private Boolean newFnskuNameIsnotnull;

  /**
   * 新Fnsku名称(精确搜索)
   */
  private List<String> newFnskuNameInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
